package Model;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import Model.Exceptions.LoteNoPerteneceALoteCompuestoException;
import Model.Exceptions.LotePerteneceAOtroLoteCompException;
import Model.Exceptions.LotePerteneceAOtroPropietarioException;
import View.ObjectViews.LoteCompuestoView;

public class LoteCompuesto extends Lote 
{
	//Atributos
	private List<Lote> lotes;
	
	//Getters
	public float getAreaSiembra()
	{
		float area = 0;
		
		for (Iterator<Lote> iterator = lotes.iterator(); iterator.hasNext();) 
		{
			Lote lote = (Lote)iterator.next();
			area += lote.getAreaSiembra();
		}
		
		return area; //tengo devolver el area de todos los lotes componentes sumadas
	}
	
	public int getCantidadLotesComponentes()
	{
		return lotes.size();
	}
	
	public Lote getLoteComponente(int index)
	{
		if (index >= 0 && index < lotes.size())
			return lotes.get(index);
		
		return null;
	}
	//Setters
	public void setAreaSiembra(float areaSiembra) 
	{
		//el "areaSiembra" del lote compuesto es 0 (se determina a partir del area de los lotes simples que lo componen)
		//No hago nada!
	}
	
	public void setPropietario(Propietario propietario) 
	{
		super.setPropietario(propietario);
		
		//Tengo que propagar el cambio a los lotes simples
		for (Iterator<Lote> iterator = lotes.iterator(); iterator.hasNext();) 
		{
			Lote lote = (Lote)iterator.next();
			lote.setPropietario(propietario);
		}
	}
	
	public void setSembrado(boolean sembrado) 
	{
		super.setSembrado(sembrado);
		
		//Tengo que propagar el cambio a los lotes simples
		for (Iterator<Lote> iterator = lotes.iterator(); iterator.hasNext();) 
		{
			Lote lote = (Lote)iterator.next();
			lote.setSembrado(sembrado);
		}
	}
	
	public void setHabilitado(boolean habilitado) 
	{
		//No lo puedo cambiar el habilitado a un LoteCompuesto
	}
	
	public void setUltimaSiembra(Siembra ultimaSiembra) 
	{
		super.setUltimaSiembra(ultimaSiembra);
		
		//Tengo que propagar el cambio a los lotes simples
		for (Iterator<Lote> iterator = lotes.iterator(); iterator.hasNext();) 
		{
			Lote lote = (Lote)iterator.next();
			lote.setUltimaSiembra(ultimaSiembra);
		}
	}
	
	public void setActivo(boolean activo) 
	{
		super.setActivo(activo);
		
		//Tengo que propagar el cambio a los lotes simples
		for (Iterator<Lote> iterator = lotes.iterator(); iterator.hasNext();) 
		{
			Lote lote = (Lote)iterator.next();
			lote.setActivo(activo);
		}
	}
	
	//Constructor
	public LoteCompuesto(int nroLote, Propietario propietario) 
	{
		super(nroLote, 0, propietario); //el "areaSiembra" del lote compuesto es 0 (se determina a partir del area de los lotes simples que lo componen)
		
		lotes = new ArrayList<Lote>();
	}

	//Metodos de negocio
	public void addLote(Lote lote) throws LotePerteneceAOtroLoteCompException, LotePerteneceAOtroPropietarioException
	{
		if (!lotes.contains(lote))
		{
			if(lote.isHabilitado())
			{
				if (this.getPropietario() == lote.getPropietario())
				{
					lote.setHabilitado(false);
					lotes.add(lote);
				}
				else
				{
					throw new LotePerteneceAOtroPropietarioException();
				}
			}
			else
			{
				throw new LotePerteneceAOtroLoteCompException();
			}
		}
	}
	
	public void removeLote(Lote lote) throws LoteNoPerteneceALoteCompuestoException
	{
		if (lotes.contains(lote))
		{
			lote.setHabilitado(true);
			lotes.remove(lote);
		}
		else
		{
			throw new LoteNoPerteneceALoteCompuestoException(this.getNro(), lote.getNro());
		}
	}

	public float getPorcentaje(Mineral mineral)
	{
		//tomo el primer valor
		float retVal = lotes.get(0).getPorcentaje(mineral);
		
		//Recorro cada Lote Simple, buscando el que menos porcentaje de este
		//mineral tiene. Si el que menos tiene tiene mas de 40% --> puedo sembrarlo en todo el lote compuesto
		for (Iterator<Lote> iterator = lotes.iterator(); iterator.hasNext();) 
		{
			Lote lote = (Lote)iterator.next();
			float porcMineral = lote.getPorcentaje(mineral);
			
			if (porcMineral < retVal)
			{
				retVal = porcMineral;
			}
		}
		
		return retVal;
	}
	
	public boolean isCompuesto() 
	{
		return true;
	}
	
	public LoteCompuestoView getView()
	{
		LoteCompuestoView loteView = new LoteCompuestoView();
		loteView.setAreaSiembra(this.getAreaSiembra());
		loteView.setCompuesto(true);
		loteView.setHabilitado(true);
		loteView.setNro(this.getNro());
		loteView.setPropietario(this.getPropietario().getView());
		
		for (Iterator<Lote> iterator = lotes.iterator(); iterator.hasNext();) 
		{
			Lote lote = (Lote)iterator.next();
			loteView.getLotes().add(lote.getView());
		}
		
		return loteView;
		
	}
}
